home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / hotjava / classsrc / java / io / file~1.jav < prev    next >
Encoding:
Text File  |  1995-08-11  |  7.4 KB  |  291 lines
  1. /*
  2.  * @(#)File.java    1.26 95/07/15 Jonathan Payne, Arthur van Hoff
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package java.io;
  21.  
  22. import java.util.Vector;
  23.  
  24. /**
  25.  * This class represents a file name of the host file system.
  26.  * The file name can be relative or absolute. It must use
  27.  * the file name conventions of the host platform. <p>
  28.  *
  29.  * The intention is to provide an abstraction that deals
  30.  * with most of the system-dependent file name features such
  31.  * as the separator character, root, device name, etc.
  32.  * Not all features are currently fully implemented.<p>
  33.  *
  34.  * Note that whenever a file name or path is  used it is
  35.  * assumed that the host's file name conventions are used.
  36.  *
  37.  * @version     1.26, 15 Jul 1995
  38.  * @author    Jonathan Payne
  39.  * @author    Arthur van Hoff
  40.  */
  41. public
  42. class File {
  43.     /**
  44.      * The path of the file. The host's file separator is used.
  45.      */
  46.     protected String path;
  47.  
  48.     /**
  49.      * File separator string. System dependent.
  50.      */
  51.     public static final String separator = getSeparator();
  52.  
  53.     /**
  54.      * File separator character. System dependent.
  55.      */
  56.     public static final char separatorChar = separator.charAt(0);
  57.  
  58.     private static native String getSeparator();
  59.     
  60.     /**
  61.      * Path separator string. System dependent.
  62.      */
  63.     public static final String pathSeparator = getPathSeparator();
  64.  
  65.     /**
  66.      * Path separator character. System dependent.
  67.      */
  68.     public static final char pathSeparatorChar = pathSeparator.charAt(0);
  69.  
  70.     private static native String getPathSeparator();
  71.     
  72.     /**
  73.      * Creates a File object.
  74.      * @param path file path
  75.      */
  76.     public File(String path) {
  77.     if (path == null) {
  78.         throw new NullPointerException();
  79.     }
  80.     this.path = path;
  81.     }    
  82.  
  83.     /**
  84.      * Creates a File object (given a directory).
  85.      * @param path directory
  86.      * @param name file name
  87.      */
  88.     public File(String path, String name) {
  89.     this((path != null) ? path + separator + name : name);
  90.     }
  91.  
  92.     /**
  93.      * Creates a File object (given a directory File object).
  94.      * @param dir the directory
  95.      * @param name file name
  96.      */
  97.     public File(File dir, String name) {
  98.     this(dir.getPath(), name);
  99.     }
  100.  
  101.     /**
  102.      * Gets the name of the file. Not including the
  103.      * directory.
  104.      */
  105.     public String getName() {
  106.     int index = path.lastIndexOf(separatorChar);
  107.     return (index < 0) ? path : path.substring(index + 1);
  108.     }
  109.  
  110.     /**
  111.      * Gets the path of the file.
  112.      */
  113.     public String getPath() {
  114.     return path;
  115.     }
  116.  
  117.     /**
  118.      * Gets the absolute path of the file.
  119.      */
  120.     public String getAbsolutePath() {
  121.     return isAbsolute() ? path : System.getCWD() + separator + path;
  122.     }
  123.  
  124.     /**
  125.      * Gets the name of the parent directory.
  126.      * @return the parent directory, or null if there isn't one
  127.      */
  128.     public String getParent() {
  129.     int index = path.lastIndexOf(separatorChar);
  130.     return (index <= 0) ? null : path.substring(0, index);
  131.     }
  132.  
  133.     /**
  134.      * Returns true if the file exists.
  135.      */
  136.     public native boolean exists();
  137.  
  138.     /**
  139.      * Returns true if the file exists and is writable.
  140.      */
  141.     public native boolean canWrite();
  142.  
  143.     /**
  144.      * Returns true if the file exists and is readable.
  145.      */
  146.     public native boolean canRead();
  147.  
  148.     /**
  149.      * Returns true if the file exists and is a normal file.
  150.      */
  151.     public native boolean isFile();
  152.  
  153.     /**
  154.      * Returns true if the file exists and is a directory.
  155.      */
  156.     public native boolean isDirectory();
  157.  
  158.     /**
  159.      * Returns true if the file name is absolute.
  160.      */
  161.     public native boolean isAbsolute();
  162.  
  163.     /**
  164.      * Returns last modification time. The return value should
  165.      * only be used to compare modifications dates. It is meaningless
  166.      * as an absolute time.
  167.      */
  168.     public native int lastModified();
  169.  
  170.     /**
  171.      * Create a directory.
  172.      * @return true if successfull
  173.      */
  174.     public native boolean mkdir();
  175.  
  176.     /**
  177.      * Rename a file.
  178.      * @return true if successfull
  179.      */
  180.     public native boolean renameTo(File dest);
  181.  
  182.     /**
  183.      * Creates all directories in this path.
  184.      */
  185.     public boolean mkdirs() {
  186.  
  187.     if (mkdir()) {
  188.          return true;
  189.      }
  190.  
  191.     String parent = getParent();
  192.     return (parent != null) && (new File(parent).mkdirs() && mkdir());
  193.     }
  194.  
  195.     /**
  196.      * Lists the files in a directory. Works only works on directories.
  197.      * @return An array of file names, this list will include all
  198.      * files in the directory except the equivalent of "." and "..".
  199.      */
  200.     public native String list()[];
  201.  
  202.     /**
  203.      * Lists the files in a directory Use the filter to select
  204.      * which files.
  205.      * @param filter the filter used to select file names
  206.      * @see FilenameFilter
  207.      */
  208.     public String list(FilenameFilter filter)[] {
  209.     String names[] = list();
  210.  
  211.     // Fill in the Vector
  212.     Vector v = new Vector();
  213.     for (int i = 0 ; i < names.length ; i++) {
  214.         if ((filter == null) || filter.accept(this, names[i])) {
  215.         v.addElement(names[i]);
  216.         }
  217.     }
  218.  
  219.     // Create the array
  220.     String files[] = new String[v.size()];
  221.     v.copyInto(files);
  222.  
  223.     return files;
  224.     }
  225.  
  226.     /**
  227.      * Computes a hashcode for the file.
  228.      */
  229.     public int hashCode() {
  230.     return path.hashCode() ^ 1234321;
  231.     }
  232.  
  233.     /**
  234.      * Compares this object against some other object.
  235.      * @param obj        the object to compare with
  236.      * @return         true if the object is the same
  237.      */
  238.     public boolean equals(Object obj) {
  239.     if ((obj != null) && (obj instanceof File)) {
  240.         return path.equals(((File)obj).path);
  241.     }
  242.     return false;
  243.     }
  244.  
  245.     /**
  246.      * Converts to a string.
  247.      */
  248.     public String toString() {
  249.     return getPath();
  250.     }
  251.     
  252.     /**
  253.      * Initializes security ACL for reading files.
  254.      * Can only be executed once.
  255.      * @param path a list of directories separated by ':'s.
  256.      */
  257.     public static native void setReadACL(String path);
  258.  
  259.     /**
  260.      * Get the value of the read ACL.
  261.      */
  262.     public static native String getReadACL();
  263.  
  264.     /**
  265.      * Initializes security ACL for writing files. 
  266.      * Can only be executed once.
  267.      * @param path a list of directories separated by ':'s.
  268.      */
  269.     public static native void setWriteACL(String path);
  270.  
  271.     /**
  272.      * Gets the value of the write ACL.
  273.      */
  274.     public static native String getWriteACL();
  275.  
  276.     /**
  277.      * Initializes security ACL for executing files. 
  278.      * Can only be executed once.
  279.      * @param path a list of directories separated by ':'s.
  280.      */
  281.     public static native void setExecACL(String path);
  282.  
  283.     /**
  284.      * Initializes the handler object which will get invoked if an
  285.      * incorrect access is attempted. The handler can override the
  286.      * acl. This method can only be invoked once.
  287.      * @see AccessErrorHandler
  288.      */
  289.     public static native void setAccessErrorHandler(AccessErrorHandler h);
  290. }
  291.